package com.evan.review.handler;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.MessageQueue;
import android.os.SystemClock;
import android.widget.Button;
import android.widget.ScrollView;
import android.widget.TextView;

import androidx.activity.EdgeToEdge;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;

import com.evan.review.R;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * 同步屏障示例
 * <p>
 * 本Activity演示同步屏障(Sync Barrier)机制，主要包括：
 * 1. 同步消息与异步消息的区别
 * 2. 同步屏障的创建和移除
 * 3. 同步屏障如何让异步消息优先执行
 * 4. 同步屏障的实际应用场景
 * <p>
 * 注意：本示例使用反射来访问非公开API，仅用于学习目的
 *
 * @noinspection DataFlowIssue
 */
public class SyncBarrierActivity extends AppCompatActivity {

    private TextView tvLog;
    private ScrollView scrollView;
    private Button btnSendSyncMessages;
    private Button btnSendAsyncMessages;
    private Button btnAddBarrier;
    private Button btnRemoveBarrier;

    // 主线程Handler
    private final Handler mHandler = new Handler(Looper.getMainLooper());

    // 发送异步消息的Handler
    @SuppressLint("DiscouragedPrivateApi")
    private final Handler asyncHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            logMessage("处理异步消息 #" + msg.arg1);
            // 模拟消息处理时间
            SystemClock.sleep(50);
        }
    };

    // 发送同步消息的Handler
    private final Handler syncHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            logMessage("处理同步消息 #" + msg.arg1);
            // 模拟消息处理时间
            SystemClock.sleep(50);
        }
    };

    // 当前同步屏障的token
    private int barrierToken = -1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        EdgeToEdge.enable(this);
        setContentView(R.layout.activity_sync_barrier);
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
            Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
            return insets;
        });

        initViews();
        setupListeners();
    }

    private void initViews() {
        tvLog = findViewById(R.id.tv_log);
        scrollView = findViewById(R.id.scroll_view);
        btnSendSyncMessages = findViewById(R.id.btn_send_sync_msgs);
        btnSendAsyncMessages = findViewById(R.id.btn_send_async_msgs);
        btnAddBarrier = findViewById(R.id.btn_add_barrier);
        btnRemoveBarrier = findViewById(R.id.btn_remove_barrier);
    }

    private void setupListeners() {
        // 发送同步消息
        btnSendSyncMessages.setOnClickListener(v -> {
            logMessage("发送5个同步消息");
            for (int i = 1; i <= 5; i++) {
                Message msg = Message.obtain(syncHandler);
                msg.arg1 = i; // 用于标识消息序号
                msg.setAsynchronous(false); // 显式设置为同步消息(默认)
                syncHandler.sendMessageDelayed(msg, i * 100);
            }
        });

        // 发送异步消息
        btnSendAsyncMessages.setOnClickListener(v -> {
            logMessage("发送5个异步消息");
            for (int i = 1; i <= 5; i++) {
                Message msg = Message.obtain(asyncHandler);
                msg.arg1 = i; // 用于标识消息序号
                // 设置为异步消息
                msg.setAsynchronous(true);
                asyncHandler.sendMessageDelayed(msg, i * 100);
            }
        });

        // 添加同步屏障
        btnAddBarrier.setOnClickListener(v -> {
            if (barrierToken == -1) {
                try {
                    barrierToken = postSyncBarrier();
                    logMessage("已添加同步屏障，token: " + barrierToken);

                    // 更新UI状态
                    btnAddBarrier.setEnabled(false);
                    btnRemoveBarrier.setEnabled(true);
                } catch (Exception e) {
                    logMessage("添加同步屏障失败: " + e.getMessage());
                }
            } else {
                logMessage("同步屏障已存在，请先移除");
            }
        });

        // 修复方法：添加同步屏障后必须发送异步消息
        /*btnAddBarrier.setOnClickListener(v -> {
            if (barrierToken == -1) {
                try {
                    barrierToken = postSyncBarrier();
                    logMessage("已添加同步屏障，token: " + barrierToken);

                    // 必须发送至少一个异步消息，或设置超时移除屏障
                    Message msg = Message.obtain();
                    msg.setAsynchronous(true);
                    asyncHandler.sendMessageDelayed(msg, 100);

                    // 安全机制：5秒后自动移除屏障，防止卡死
                    asyncHandler.postDelayed(() -> {
                        try {
                            if (barrierToken != -1) {
                                removeSyncBarrier(barrierToken);
                                barrierToken = -1;
                                logMessage("已自动移除同步屏障");
                            }
                        } catch (Exception e) {
                            // 处理异常
                        }
                    }, 5000);

                    // 更新UI状态
                    btnAddBarrier.setEnabled(false);
                    btnRemoveBarrier.setEnabled(true);
                } catch (Exception e) {
                    logMessage("添加同步屏障失败: " + e.getMessage());
                }
            }
        });*/

        // 移除同步屏障
        btnRemoveBarrier.setOnClickListener(v -> {
            if (barrierToken != -1) {
                try {
                    removeSyncBarrier(barrierToken);
                    logMessage("已移除同步屏障，token: " + barrierToken);
                    barrierToken = -1;

                    // 更新UI状态
                    btnAddBarrier.setEnabled(true);
                    btnRemoveBarrier.setEnabled(false);
                } catch (Exception e) {
                    logMessage("移除同步屏障失败: " + e.getMessage());
                }
            } else {
                logMessage("没有同步屏障需要移除");
            }
        });
    }

    /**
     * 发送同步屏障
     * 注意：这是使用反射访问非公开API，仅用于教学演示
     * 在实际应用中，同步屏障主要由系统内部使用
     */
    @SuppressLint("DiscouragedPrivateApi")
    private int postSyncBarrier() throws Exception {
        // 获取MessageQueue
        MessageQueue queue = Looper.getMainLooper().getQueue();

        // 通过反射获取postSyncBarrier方法
        Method method = MessageQueue.class.getDeclaredMethod("postSyncBarrier");
        method.setAccessible(true);

        // 调用方法并获取token
        return (int) method.invoke(queue);
    }


    /**
     * 移除同步屏障
     * 注意：这是使用反射访问非公开API，仅用于教学演示
     */
    @SuppressLint("DiscouragedPrivateApi")
    private void removeSyncBarrier(int token) throws Exception {
        // 获取MessageQueue
        MessageQueue queue = Looper.getMainLooper().getQueue();

        // 通过反射获取removeSyncBarrier方法
        Method method = MessageQueue.class.getDeclaredMethod("removeSyncBarrier", int.class);
        method.setAccessible(true);

        // 调用方法
        method.invoke(queue, token);
    }

    /**
     * 记录日志消息到UI
     */
    private void logMessage(String message) {
        if (isFinishing()) return;

        String timeStamp = new SimpleDateFormat("HH:mm:ss.SSS", Locale.getDefault())
                .format(new Date());

        final String logMsg = "[" + timeStamp + "] " + message;

        mHandler.post(() -> {
            tvLog.append(logMsg + "\n");
            // 自动滚动到底部
            scrollView.post(() -> scrollView.fullScroll(ScrollView.FOCUS_DOWN));
        });
    }

    /**
     * 演示同步屏障的实际应用场景
     */
    private void demonstrateRealWorldUsage() {
        logMessage("\n--- 实际应用场景演示 ---");

        logMessage("场景：UI绘制需要高优先级处理");
        logMessage("Android中，Choreographer使用同步屏障确保VSYNC信号和UI渲染消息的优先处理");

        // 在实际开发中，我们很少直接使用同步屏障
        // 但View系统内部会使用它来确保动画和UI绘制的流畅性
    }

    @Override
    protected void onResume() {
        super.onResume();
        // UI初始状态
        btnAddBarrier.setEnabled(true);
        btnRemoveBarrier.setEnabled(false);

        // 演示实际使用场景
        mHandler.postDelayed(this::demonstrateRealWorldUsage, 1000);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // 确保移除所有屏障
        if (barrierToken != -1) {
            try {
                removeSyncBarrier(barrierToken);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 清理工作
        mHandler.removeCallbacksAndMessages(null);
        syncHandler.removeCallbacksAndMessages(null);
        asyncHandler.removeCallbacksAndMessages(null);
    }
} 